home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / flex_247.zip / flex_247 / main.c < prev    next >
C/C++ Source or Header  |  1994-01-04  |  25KB  |  990 lines
  1. /* flex - tool to generate fast lexical analyzers */
  2.  
  3. /*-
  4.  * Copyright (c) 1990 The Regents of the University of California.
  5.  * All rights reserved.
  6.  *
  7.  * This code is derived from software contributed to Berkeley by
  8.  * Vern Paxson.
  9.  * 
  10.  * The United States Government has rights in this work pursuant
  11.  * to contract no. DE-AC03-76SF00098 between the United States
  12.  * Department of Energy and the University of California.
  13.  *
  14.  * Redistribution and use in source and binary forms are permitted provided
  15.  * that: (1) source distributions retain this entire copyright notice and
  16.  * comment, and (2) distributions including binaries display the following
  17.  * acknowledgement:  ``This product includes software developed by the
  18.  * University of California, Berkeley and its contributors'' in the
  19.  * documentation or other materials provided with the distribution and in
  20.  * all advertising materials mentioning features or use of this software.
  21.  * Neither the name of the University nor the names of its contributors may
  22.  * be used to endorse or promote products derived from this software without
  23.  * specific prior written permission.
  24.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  25.  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  26.  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  27.  */
  28.  
  29. #ifndef lint
  30. char copyright[] =
  31. "@(#) Copyright (c) 1990 The Regents of the University of California.\n\
  32.  All rights reserved.\n";
  33. #endif /* not lint */
  34.  
  35. /* $Header: main.c,v 1.2 94/01/04 14:33:11 vern Exp $ */
  36.  
  37.  
  38. #include "flexdef.h"
  39. #include "version.h"
  40.  
  41. static char flex_version[] = FLEX_VERSION;
  42.  
  43.  
  44. /* declare functions that have forward references */
  45.  
  46. void flexinit PROTO((int, char**));
  47. void readin PROTO((void));
  48. void set_up_initial_allocations PROTO((void));
  49.  
  50.  
  51. /* these globals are all defined and commented in flexdef.h */
  52. int printstats, syntaxerror, eofseen, ddebug, trace, nowarn, spprdflt;
  53. int interactive, caseins, lex_compat, useecs, fulltbl, usemecs;
  54. int fullspd, gen_line_dirs, performance_report, backing_up_report;
  55. int C_plus_plus, long_align, use_read, yytext_is_array, csize;
  56. int yymore_used, reject, real_reject, continued_action;
  57. int yymore_really_used, reject_really_used;
  58. int datapos, dataline, linenum;
  59. FILE *skelfile = NULL;
  60. int skel_ind = 0;
  61. char *action_array;
  62. int action_size, defs1_offset, prolog_offset, action_offset, action_index;
  63. char *infilename = NULL;
  64. int onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE];
  65. int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp;
  66. int current_mns, num_rules, num_eof_rules, default_rule;
  67. int current_max_rules, lastnfa;
  68. int *firstst, *lastst, *finalst, *transchar, *trans1, *trans2;
  69. int *accptnum, *assoc_rule, *state_type;
  70. int *rule_type, *rule_linenum, *rule_useful;
  71. int current_state_type;
  72. int variable_trailing_context_rules;
  73. int numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP];
  74. int protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE];
  75. int numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs, tecfwd[CSIZE + 1];
  76. int tecbck[CSIZE + 1];
  77. int lastsc, current_max_scs, *scset, *scbol, *scxclu, *sceof, *actvsc;
  78. char **scname;
  79. int current_max_dfa_size, current_max_xpairs;
  80. int current_max_template_xpairs, current_max_dfas;
  81. int lastdfa, *nxt, *chk, *tnxt;
  82. int *base, *def, *nultrans, NUL_ec, tblend, firstfree, **dss, *dfasiz;
  83. union dfaacc_union *dfaacc;
  84. int *accsiz, *dhash, numas;
  85. int numsnpairs, jambase, jamstate;
  86. int lastccl, current_maxccls, *cclmap, *ccllen, *cclng, cclreuse;
  87. int current_max_ccl_tbl_size;
  88. Char *ccltbl;
  89. char nmstr[MAXLINE];
  90. int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs;
  91. int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave;
  92. int num_backing_up, bol_needed;
  93. FILE *backing_up_file;
  94. int end_of_buffer_state;
  95. char **input_files;
  96. int num_input_files;
  97. char *program_name;
  98.  
  99. #ifndef SHORT_FILE_NAMES
  100. static char *outfile_template = "lex.%s.%s";
  101. #else
  102. static char *outfile_template = "lex%s.%s";
  103. #endif
  104. static char outfile_path[64];
  105.  
  106. static int outfile_created = 0;
  107. static int use_stdout;
  108. static char *skelname = NULL;
  109. static char *prefix = "yy";
  110.  
  111.  
  112. int main( argc, argv )
  113. int argc;
  114. char **argv;
  115.     {
  116.     int i;
  117.  
  118.     flexinit( argc, argv );
  119.  
  120.     readin();
  121.  
  122.     ntod();
  123.  
  124.     for ( i = 1; i <= num_rules; ++i )
  125.         if ( ! rule_useful[i] && i != default_rule )
  126.             line_warning( "rule cannot be matched",
  127.                     rule_linenum[i] );
  128.  
  129.     if ( spprdflt && ! reject && rule_useful[default_rule] )
  130.         line_warning( "-s option given but default rule can be matched",
  131.             rule_linenum[default_rule] );
  132.  
  133.     /* Generate the C state transition tables from the DFA. */
  134.     make_tables();
  135.  
  136.     /* Note, flexend does not return.  It exits with its argument
  137.      * as status.
  138.      */
  139.     flexend( 0 );
  140.  
  141.     return 0;    /* keep compilers/lint happy */
  142.     }
  143.  
  144.  
  145. /* flexend - terminate flex
  146.  *
  147.  * note
  148.  *    This routine does not return.
  149.  */
  150.  
  151. void flexend( exit_status )
  152. int exit_status;
  153.  
  154.     {
  155.     int tblsiz;
  156.     int unlink();
  157.  
  158.     if ( skelfile != NULL )
  159.         {
  160.         if ( ferror( skelfile ) )
  161.             flexfatal(
  162.                 "error occurred when reading skeleton file" );
  163.  
  164.         else if ( fclose( skelfile ) )
  165.             flexfatal(
  166.                 "error occurred when closing skeleton file" );
  167.         }
  168.  
  169.     if ( exit_status != 0 && outfile_created )
  170.         {
  171.         if ( ferror( stdout ) )
  172.             flexfatal( "error occurred when writing output file" );
  173.  
  174.         else if ( fclose( stdout ) )
  175.             flexfatal( "error occurred when closing output file" );
  176.  
  177.         else if ( unlink( outfile_path ) )
  178.             flexfatal( "error occurred when deleting output file" );
  179.         }
  180.  
  181.     if ( backing_up_report && backing_up_file )
  182.         {
  183.         if ( num_backing_up == 0 )
  184.             fprintf( backing_up_file, "No backing up.\n" );
  185.         else if ( fullspd || fulltbl )
  186.             fprintf( backing_up_file,
  187.                 "%d backing up (non-accepting) states.\n",
  188.                 num_backing_up );
  189.         else
  190.             fprintf( backing_up_file,
  191.                 "Compressed tables always back up.\n" );
  192.  
  193.         if ( ferror( backing_up_file ) )
  194.             flexfatal( "error occurred when writing backup file" );
  195.  
  196.         else if ( fclose( backing_up_file ) )
  197.             flexfatal( "error occurred when closing backup file" );
  198.         }
  199.  
  200.     if ( printstats )
  201.         {
  202.         fprintf( stderr, "%s version %s usage statistics:\n",
  203.             program_name, flex_version );
  204.  
  205.         fprintf( stderr, "  scanner options: -" );
  206.  
  207.         if ( C_plus_plus )
  208.             putc( '+', stderr );
  209.         if ( backing_up_report )
  210.             putc( 'b', stderr );
  211.         if ( ddebug )
  212.             putc( 'd', stderr );
  213.         if ( caseins )
  214.             putc( 'i', stderr );
  215.         if ( lex_compat )
  216.             putc( 'l', stderr );
  217.         if ( performance_report > 0 )
  218.             putc( 'p', stderr );
  219.         if ( performance_report > 1 )
  220.             putc( 'p', stderr );
  221.         if ( spprdflt )
  222.             putc( 's', stderr );
  223.         if ( use_stdout )
  224.             putc( 't', stderr );
  225.         if ( printstats )
  226.             putc( 'v', stderr );    /* always true! */
  227.         if ( nowarn )
  228.             putc( 'w', stderr );
  229.         if ( ! interactive )
  230.             putc( 'B', stderr );
  231.         if ( interactive )
  232.             putc( 'I', stderr );
  233.         if ( ! gen_line_dirs )
  234.             putc( 'L', stderr );
  235.         if ( trace )
  236.             putc( 'T', stderr );
  237.         if ( csize == 128 )
  238.             putc( '7', stderr );
  239.         else
  240.             putc( '8', stderr );
  241.  
  242.         fprintf( stderr, " -C" );
  243.  
  244.         if ( long_align )
  245.             putc( 'a', stderr );
  246.         if ( fulltbl )
  247.             putc( 'f', stderr );
  248.         if ( fullspd )
  249.             putc( 'F', stderr );
  250.         if ( useecs )
  251.             putc( 'e', stderr );
  252.         if ( usemecs )
  253.             putc( 'm', stderr );
  254.         if ( use_read )
  255.             putc( 'r', stderr );
  256.  
  257.         if ( skelname )
  258.             fprintf( stderr, " -S%s", skelname );
  259.  
  260.         if ( strcmp( prefix, "yy" ) )
  261.             fprintf( stderr, " -P%s", prefix );
  262.  
  263.         putc( '\n', stderr );
  264.  
  265.         fprintf( stderr, "  %d/%d NFA states\n", lastnfa, current_mns );
  266.         fprintf( stderr, "  %d/%d DFA states (%d words)\n", lastdfa,
  267.             current_max_dfas, totnst );
  268.         fprintf( stderr, "  %d rules\n",
  269.         num_rules + num_eof_rules - 1 /* - 1 for def. rule */ );
  270.  
  271.         if ( num_backing_up == 0 )
  272.             fprintf( stderr, "  No backing up\n" );
  273.         else if ( fullspd || fulltbl )
  274.             fprintf( stderr,
  275.                 "  %d backing-up (non-accepting) states\n",
  276.                 num_backing_up );
  277.         else
  278.             fprintf( stderr,
  279.                 "  Compressed tables always back-up\n" );
  280.  
  281.         if ( bol_needed )
  282.             fprintf( stderr,
  283.                 "  Beginning-of-line patterns used\n" );
  284.  
  285.         fprintf( stderr, "  %d/%d start conditions\n", lastsc,
  286.             current_max_scs );
  287.         fprintf( stderr,
  288.             "  %d epsilon states, %d double epsilon states\n",
  289.             numeps, eps2 );
  290.  
  291.         if ( lastccl == 0 )
  292.             fprintf( stderr, "  no character classes\n" );
  293.         else
  294.             fprintf( stderr,
  295.     "  %d/%d character classes needed %d/%d words of storage, %d reused\n",
  296.                 lastccl, current_maxccls,
  297.                 cclmap[lastccl] + ccllen[lastccl],
  298.                 current_max_ccl_tbl_size, cclreuse );
  299.  
  300.         fprintf( stderr, "  %d state/nextstate pairs created\n",
  301.             numsnpairs );
  302.         fprintf( stderr, "  %d/%d unique/duplicate transitions\n",
  303.             numuniq, numdup );
  304.  
  305.         if ( fulltbl )
  306.             {
  307.             tblsiz = lastdfa * numecs;
  308.             fprintf( stderr, "  %d table entries\n", tblsiz );
  309.             }
  310.  
  311.         else
  312.             {
  313.             tblsiz = 2 * (lastdfa + numtemps) + 2 * tblend;
  314.  
  315.             fprintf( stderr, "  %d/%d base-def entries created\n",
  316.                 lastdfa + numtemps, current_max_dfas );
  317.             fprintf( stderr,
  318.                 "  %d/%d (peak %d) nxt-chk entries created\n",
  319.                 tblend, current_max_xpairs, peakpairs );
  320.             fprintf( stderr,
  321.             "  %d/%d (peak %d) template nxt-chk entries created\n",
  322.                 numtemps * nummecs, current_max_template_xpairs,
  323.                 numtemps * numecs );
  324.             fprintf( stderr, "  %d empty table entries\n", nummt );
  325.             fprintf( stderr, "  %d protos created\n", numprots );
  326.             fprintf( stderr, "  %d templates created, %d uses\n",
  327.                 numtemps, tmpuses );
  328.             }
  329.  
  330.         if ( useecs )
  331.             {
  332.             tblsiz = tblsiz + csize;
  333.             fprintf( stderr,
  334.                 "  %d/%d equivalence classes created\n",
  335.                 numecs, csize );
  336.             }
  337.  
  338.         if ( usemecs )
  339.             {
  340.             tblsiz = tblsiz + numecs;
  341.             fprintf( stderr,
  342.                 "  %d/%d meta-equivalence classes created\n",
  343.                 nummecs, csize );
  344.             }
  345.  
  346.         fprintf( stderr,
  347.             "  %d (%d saved) hash collisions, %d DFAs equal\n",
  348.             hshcol, hshsave, dfaeql );
  349.         fprintf( stderr, "  %d sets of reallocations needed\n",
  350.             num_reallocs );
  351.         fprintf( stderr, "  %d total table entries needed\n", tblsiz );
  352.         }
  353.  
  354. #ifndef VMS
  355.     exit( exit_status );
  356. #else
  357.     exit( exit_status + 1 );
  358. #endif
  359.     }
  360.  
  361.  
  362. /* flexinit - initialize flex */
  363.  
  364. void flexinit( argc, argv )
  365. int argc;
  366. char **argv;
  367.     {
  368.     int i, sawcmpflag;
  369.     int csize_given, interactive_given;
  370.     char *arg, *mktemp();
  371.  
  372.     printstats = syntaxerror = trace = spprdflt = caseins = false;
  373.     lex_compat = false;
  374.     C_plus_plus = backing_up_report = ddebug = fulltbl = fullspd = false;
  375.     long_align = nowarn = yymore_used = continued_action = reject = false;
  376.     yytext_is_array = yymore_really_used = reject_really_used = false;
  377.     gen_line_dirs = usemecs = useecs = true;
  378.     performance_report = 0;
  379.  
  380.     sawcmpflag = false;
  381.     use_read = use_stdout = false;
  382.     csize_given = false;
  383.     interactive_given = false;
  384.  
  385.     /* Initialize dynamic array for holding the rule actions. */
  386.     action_size = 2048;    /* default size of action array in bytes */
  387.     action_array = allocate_character_array( action_size );
  388.     defs1_offset = prolog_offset = action_offset = action_index = 0;
  389.     action_array[0] = '\0';
  390.  
  391.     program_name = argv[0];
  392.  
  393.     if ( program_name[0] != '\0' &&
  394.          program_name[strlen( program_name ) - 1] == '+' )
  395.         C_plus_plus = true;
  396.  
  397.     /* read flags */
  398.     for ( --argc, ++argv; argc ; --argc, ++argv )
  399.         {
  400.         if ( argv[0][0] != '-' || argv[0][1] == '\0' )
  401.             break;
  402.  
  403.         arg = argv[0];
  404.  
  405.         for ( i = 1; arg[i] != '\0'; ++i )
  406.             switch ( arg[i] )
  407.                 {
  408.                 case '+':
  409.                     C_plus_plus = true;
  410.                     break;
  411.  
  412.                 case 'B':
  413.                     interactive = false;
  414.                     interactive_given = true;
  415.                     break;
  416.  
  417.                 case 'b':
  418.                     backing_up_report = true;
  419.                     break;
  420.  
  421.                 case 'c':
  422.                     fprintf( stderr,
  423.     "%s: Assuming use of deprecated -c flag is really intended to be -C\n",
  424.                     program_name );
  425.  
  426.                     /* fall through */
  427.  
  428.                 case 'C':
  429.                     if ( i != 1 )
  430.                         flexerror(
  431.                     "-C flag must be given separately" );
  432.  
  433.                     if ( ! sawcmpflag )
  434.                         {
  435.                         useecs = false;
  436.                         usemecs = false;
  437.                         fulltbl = false;
  438.                         sawcmpflag = true;
  439.                         }
  440.  
  441.                     for ( ++i; arg[i] != '\0'; ++i )
  442.                         switch ( arg[i] )
  443.                             {
  444.                             case 'a':
  445.                                 long_align =
  446.                                     true;
  447.                                 break;
  448.  
  449.                             case 'e':
  450.                                 useecs = true;
  451.                                 break;
  452.  
  453.                             case 'F':
  454.                                 fullspd = true;
  455.                                 break;
  456.  
  457.                             case 'f':
  458.                                 fulltbl = true;
  459.                                 break;
  460.  
  461.                             case 'm':
  462.                                 usemecs = true;
  463.                                 break;
  464.  
  465.                             case 'r':
  466.                                 use_read = true;
  467.                                 break;
  468.  
  469.                             default:
  470.                                 lerrif(
  471.                         "unknown -C option '%c'",
  472.                                 (int) arg[i] );
  473.                                 break;
  474.                             }
  475.  
  476.                     goto get_next_arg;
  477.  
  478.                 case 'd':
  479.                     ddebug = true;
  480.                     break;
  481.  
  482.                 case 'f':
  483.                     useecs = usemecs = false;
  484.                     use_read = fulltbl = true;
  485.                     break;
  486.  
  487.                 case 'F':
  488.                     useecs = usemecs = false;
  489.                     use_read = fullspd = true;
  490.                     break;
  491.  
  492.                 case 'h':
  493.                     usage();
  494.                     exit( 0 );
  495.  
  496.                 case 'I':
  497.                     interactive = true;
  498.                     interactive_given = true;
  499.                     break;
  500.  
  501.                 case 'i':
  502.                     caseins = true;
  503.                     break;
  504.  
  505.                 case 'l':
  506.                     lex_compat = true;
  507.                     break;
  508.  
  509.                 case 'L':
  510.                     gen_line_dirs = false;
  511.                     break;
  512.  
  513.                 case 'n':
  514.                     /* Stupid do-nothing deprecated
  515.                      * option.
  516.                      */
  517.                     break;
  518.  
  519.                 case 'P':
  520.                     if ( i != 1 )
  521.                         flexerror(
  522.                     "-P flag must be given separately" );
  523.  
  524.                     prefix = arg + i + 1;
  525.                     goto get_next_arg;
  526.  
  527.                 case 'p':
  528.                     ++performance_report;
  529.                     break;
  530.  
  531.                 case 'S':
  532.                     if ( i != 1 )
  533.                         flexerror(
  534.                     "-S flag must be given separately" );
  535.  
  536.                     skelname = arg + i + 1;
  537.                     goto get_next_arg;
  538.  
  539.                 case 's':
  540.                     spprdflt = true;
  541.                     break;
  542.  
  543.                 case 't':
  544.                     use_stdout = true;
  545.                     break;
  546.  
  547.                 case 'T':
  548.                     trace = true;
  549.                     break;
  550.  
  551.                 case 'v':
  552.                     printstats = true;
  553.                     break;
  554.  
  555.                 case 'V':
  556.                     fprintf( stderr, "%s version %s\n",
  557.                         program_name, flex_version );
  558.                     exit( 0 );
  559.  
  560.                 case 'w':
  561.                     nowarn = true;
  562.                     break;
  563.  
  564.                 case '7':
  565.                     csize = 128;
  566.                     csize_given = true;
  567.                     break;
  568.  
  569.                 case '8':
  570.                     csize = CSIZE;
  571.                     csize_given = true;
  572.                     break;
  573.  
  574.                 default:
  575.                     fprintf( stderr,
  576.                         "%s: unknown flag '%c'\n",
  577.                         program_name, (int) arg[i] );
  578.                     usage();
  579.                     exit( 1 );
  580.                 }
  581.  
  582.         /* Used by -C, -S and -P flags in lieu of a "continue 2"
  583.          * control.
  584.          */
  585.         get_next_arg: ;
  586.         }
  587.  
  588.     if ( ! csize_given )
  589.         {
  590.         if ( (fulltbl || fullspd) && ! useecs )
  591.             csize = DEFAULT_CSIZE;
  592.         else
  593.             csize = CSIZE;
  594.         }
  595.  
  596.     if ( ! interactive_given )
  597.         {
  598.         if ( fulltbl || fullspd )
  599.             interactive = false;
  600.         else
  601.             interactive = true;
  602.         }
  603.  
  604.     if ( lex_compat )
  605.         {
  606.         if ( C_plus_plus )
  607.             flexerror( "Can't use -+ with -l option" );
  608.  
  609.         if ( fulltbl || fullspd )
  610.             flexerror( "Can't use -f or -F with -l option" );
  611.  
  612.         /* Don't rely on detecting use of yymore() and REJECT,
  613.          * just assume they'll be used.
  614.          */
  615.         yymore_really_used = reject_really_used = true;
  616.  
  617.         yytext_is_array = true;
  618.         use_read = false;
  619.         }
  620.  
  621.     if ( (fulltbl || fullspd) && usemecs )
  622.         flexerror( "-Cf/-CF and -Cm don't make sense together" );
  623.  
  624.     if ( (fulltbl || fullspd) && interactive )
  625.         flexerror( "-Cf/-CF and -I are incompatible" );
  626.  
  627.     if ( fulltbl && fullspd )
  628.         flexerror( "-Cf and -CF are mutually exclusive" );
  629.  
  630.     if ( C_plus_plus && fullspd )
  631.         flexerror( "Can't use -+ with -CF option" );
  632.  
  633.     if ( ! use_stdout )
  634.         {
  635.         FILE *prev_stdout;
  636.         char *suffix;
  637.  
  638.         if ( C_plus_plus )
  639.             suffix = "cc";
  640.         else
  641.             suffix = "c";
  642.  
  643.         sprintf( outfile_path, outfile_template, prefix, suffix );
  644.  
  645.         prev_stdout = freopen( outfile_path, "w", stdout );
  646.  
  647.         if ( prev_stdout == NULL )
  648.             lerrsf( "could not create %s", outfile_path );
  649.  
  650.         outfile_created = 1;
  651.         }
  652.  
  653.     num_input_files = argc;
  654.     input_files = argv;
  655.     set_input_file( num_input_files > 0 ? input_files[0] : NULL );
  656.  
  657.     if ( backing_up_report )
  658.         {
  659. #ifndef SHORT_FILE_NAMES
  660.         backing_up_file = fopen( "lex.backup", "w" );
  661. #else
  662.         backing_up_file = fopen( "lex.bck", "w" );
  663. #endif
  664.  
  665.         if ( backing_up_file == NULL )
  666.             flexerror( "could not create lex.backup" );
  667.         }
  668.  
  669.     else
  670.         backing_up_file = NULL;
  671.  
  672.  
  673.     lastccl = 0;
  674.     lastsc = 0;
  675.  
  676.     if ( skelname && (skelfile = fopen( skelname, "r" )) == NULL )
  677.         lerrsf( "can't open skeleton file %s", skelname );
  678.  
  679.     if ( strcmp( prefix, "yy" ) )
  680.         {
  681. #define GEN_PREFIX(name) printf( "#define yy%s %s%s\n", name, prefix, name );
  682.         GEN_PREFIX( "FlexLexer" );
  683.         GEN_PREFIX( "_create_buffer" );
  684.         GEN_PREFIX( "_delete_buffer" );
  685.         GEN_PREFIX( "_flex_debug" );
  686.         GEN_PREFIX( "_init_buffer" );
  687.         GEN_PREFIX( "_load_buffer_state" );
  688.         GEN_PREFIX( "_switch_to_buffer" );
  689.         GEN_PREFIX( "in" );
  690.         GEN_PREFIX( "leng" );
  691.         GEN_PREFIX( "lex" );
  692.         GEN_PREFIX( "out" );
  693.         GEN_PREFIX( "restart" );
  694.         GEN_PREFIX( "text" );
  695.         GEN_PREFIX( "wrap" );
  696.         printf( "\n" );
  697.         }
  698.  
  699.  
  700.     lastdfa = lastnfa = 0;
  701.     num_rules = num_eof_rules = default_rule = 0;
  702.     numas = numsnpairs = tmpuses = 0;
  703.     numecs = numeps = eps2 = num_reallocs = hshcol = dfaeql = totnst = 0;
  704.     numuniq = numdup = hshsave = eofseen = datapos = dataline = 0;
  705.     num_backing_up = onesp = numprots = 0;
  706.     variable_trailing_context_rules = bol_needed = false;
  707.  
  708.     linenum = sectnum = 1;
  709.     firstprot = NIL;
  710.  
  711.     /* Used in mkprot() so that the first proto goes in slot 1
  712.      * of the proto queue.
  713.      */
  714.     lastprot = 1;
  715.  
  716.     if ( useecs )
  717.         {
  718.         /* Set up doubly-linked equivalence classes. */
  719.  
  720.         /* We loop all the way up to csize, since ecgroup[csize] is
  721.          * the position used for NUL characters.
  722.          */
  723.         ecgroup[1] = NIL;
  724.  
  725.         for ( i = 2; i <= csize; ++i )
  726.             {
  727.             ecgroup[i] = i - 1;
  728.             nextecm[i - 1] = i;
  729.             }
  730.  
  731.         nextecm[csize] = NIL;
  732.         }
  733.  
  734.     else
  735.         {
  736.         /* Put everything in its own equivalence class. */
  737.         for ( i = 1; i <= csize; ++i )
  738.             {
  739.             ecgroup[i] = i;
  740.             nextecm[i] = BAD_SUBSCRIPT;    /* to catch errors */
  741.             }
  742.         }
  743.  
  744.     set_up_initial_allocations();
  745.     }
  746.  
  747.  
  748. /* readin - read in the rules section of the input file(s) */
  749.  
  750. void readin()
  751.     {
  752.     skelout();
  753.  
  754.     line_directive_out( (FILE *) 0 );
  755.  
  756.     if ( yyparse() )
  757.         {
  758.         pinpoint_message( "fatal parse error" );
  759.         flexend( 1 );
  760.         }
  761.  
  762.     if ( syntaxerror )
  763.         flexend( 1 );
  764.  
  765.     if ( yymore_really_used == REALLY_USED )
  766.         yymore_used = true;
  767.     else if ( yymore_really_used == REALLY_NOT_USED )
  768.         yymore_used = false;
  769.  
  770.     if ( reject_really_used == REALLY_USED )
  771.         reject = true;
  772.     else if ( reject_really_used == REALLY_NOT_USED )
  773.         reject = false;
  774.  
  775.     if ( performance_report > 0 )
  776.         {
  777.         if ( lex_compat )
  778.             {
  779.             fprintf( stderr,
  780. "-l AT&T lex compatibility option entails a large performance penalty\n" );
  781.             fprintf( stderr,
  782. " and may be the actual source of other reported performance penalties\n" );
  783.             }
  784.  
  785.         if ( performance_report > 1 )
  786.             {
  787.             if ( interactive )
  788.                 fprintf( stderr,
  789.         "-I (interactive) entails a minor performance penalty\n" );
  790.  
  791.             if ( yymore_used )
  792.                 fprintf( stderr,
  793.             "yymore() entails a minor performance penalty\n" );
  794.             }
  795.  
  796.         if ( reject )
  797.             fprintf( stderr,
  798.             "REJECT entails a large performance penalty\n" );
  799.  
  800.         if ( variable_trailing_context_rules )
  801.             fprintf( stderr,
  802. "Variable trailing context rules entail a large performance penalty\n" );
  803.         }
  804.  
  805.     if ( reject )
  806.         real_reject = true;
  807.  
  808.     if ( variable_trailing_context_rules )
  809.         reject = true;
  810.  
  811.     if ( (fulltbl || fullspd) && reject )
  812.         {
  813.         if ( real_reject )
  814.             flexerror( "REJECT cannot be used with -f or -F" );
  815.         else
  816.             flexerror(
  817.     "variable trailing context rules cannot be used with -f or -F" );
  818.         }
  819.  
  820.     if ( csize == 256 )
  821.         puts( "typedef unsigned char YY_CHAR;" );
  822.     else
  823.         puts( "typedef char YY_CHAR;" );
  824.  
  825.     if ( C_plus_plus )
  826.         {
  827.         puts( "#define yytext_ptr yytext" );
  828.  
  829.         if ( interactive )
  830.             puts( "#define YY_INTERACTIVE" );
  831.         }
  832.  
  833.     if ( fullspd )
  834.         printf(
  835.         "typedef const struct yy_trans_info *yy_state_type;\n" );
  836.     else if ( ! C_plus_plus )
  837.         printf( "typedef int yy_state_type;\n" );
  838.  
  839.     if ( reject )
  840.         printf( "\n#define YY_USES_REJECT\n" );
  841.  
  842.     if ( ddebug )
  843.         puts( "\n#define FLEX_DEBUG" );
  844.  
  845.     if ( lex_compat )
  846.         {
  847.         printf( "FILE *yyin = stdin, *yyout = stdout;\n" );
  848.         printf( "extern int yylineno;\n" );
  849.         printf( "int yylineno = 1;\n" );
  850.         }
  851.     else if ( ! C_plus_plus )
  852.         printf( "FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;\n" );
  853.  
  854.     if ( C_plus_plus )
  855.         printf( "\n#include <FlexLexer.h>\n" );
  856.  
  857.     else
  858.         {
  859.         if ( yytext_is_array )
  860.             puts( "extern char yytext[];\n" );
  861.  
  862.         else
  863.             {
  864.             puts( "extern char *yytext;" );
  865.             puts( "#define yytext_ptr yytext" );
  866.             }
  867.         }
  868.  
  869.     if ( useecs )
  870.         numecs = cre8ecs( nextecm, ecgroup, csize );
  871.     else
  872.         numecs = csize;
  873.  
  874.     /* Now map the equivalence class for NUL to its expected place. */
  875.     ecgroup[0] = ecgroup[csize];
  876.     NUL_ec = ABS( ecgroup[0] );
  877.  
  878.     if ( useecs )
  879.         ccl2ecl();
  880.     }
  881.  
  882.  
  883. /* set_up_initial_allocations - allocate memory for internal tables */
  884.  
  885. void set_up_initial_allocations()
  886.     {
  887.     current_mns = INITIAL_MNS;
  888.     firstst = allocate_integer_array( current_mns );
  889.     lastst = allocate_integer_array( current_mns );
  890.     finalst = allocate_integer_array( current_mns );
  891.     transchar = allocate_integer_array( current_mns );
  892.     trans1 = allocate_integer_array( current_mns );
  893.     trans2 = allocate_integer_array( current_mns );
  894.     accptnum = allocate_integer_array( current_mns );
  895.     assoc_rule = allocate_integer_array( current_mns );
  896.     state_type = allocate_integer_array( current_mns );
  897.  
  898.     current_max_rules = INITIAL_MAX_RULES;
  899.     rule_type = allocate_integer_array( current_max_rules );
  900.     rule_linenum = allocate_integer_array( current_max_rules );
  901.     rule_useful = allocate_integer_array( current_max_rules );
  902.  
  903.     current_max_scs = INITIAL_MAX_SCS;
  904.     scset = allocate_integer_array( current_max_scs );
  905.     scbol = allocate_integer_array( current_max_scs );
  906.     scxclu = allocate_integer_array( current_max_scs );
  907.     sceof = allocate_integer_array( current_max_scs );
  908.     scname = allocate_char_ptr_array( current_max_scs );
  909.     actvsc = allocate_integer_array( current_max_scs );
  910.  
  911.     current_maxccls = INITIAL_MAX_CCLS;
  912.     cclmap = allocate_integer_array( current_maxccls );
  913.     ccllen = allocate_integer_array( current_maxccls );
  914.     cclng = allocate_integer_array( current_maxccls );
  915.  
  916.     current_max_ccl_tbl_size = INITIAL_MAX_CCL_TBL_SIZE;
  917.     ccltbl = allocate_Character_array( current_max_ccl_tbl_size );
  918.  
  919.     current_max_dfa_size = INITIAL_MAX_DFA_SIZE;
  920.  
  921.     current_max_xpairs = INITIAL_MAX_XPAIRS;
  922.     nxt = allocate_integer_array( current_max_xpairs );
  923.     chk = allocate_integer_array( current_max_xpairs );
  924.  
  925.     current_max_template_xpairs = INITIAL_MAX_TEMPLATE_XPAIRS;
  926.     tnxt = allocate_integer_array( current_max_template_xpairs );
  927.  
  928.     current_max_dfas = INITIAL_MAX_DFAS;
  929.     base = allocate_integer_array( current_max_dfas );
  930.     def = allocate_integer_array( current_max_dfas );
  931.     dfasiz = allocate_integer_array( current_max_dfas );
  932.     accsiz = allocate_integer_array( current_max_dfas );
  933.     dhash = allocate_integer_array( current_max_dfas );
  934.     dss = allocate_int_ptr_array( current_max_dfas );
  935.     dfaacc = allocate_dfaacc_union( current_max_dfas );
  936.  
  937.     nultrans = (int *) 0;
  938.     }
  939.  
  940.  
  941. void usage()
  942.     {
  943.     fprintf( stderr,
  944. "%s [-bcdfhilnpstvwBFILTV78+ -C[aefFmr] -Pprefix -Sskeleton] [file ...]\n",
  945.         program_name );
  946.  
  947.     fprintf( stderr,
  948.         "\t-b  generate backing-up information to lex.backup\n" );
  949.     fprintf( stderr, "\t-c  do-nothing POSIX option\n" );
  950.     fprintf( stderr, "\t-d  turn on debug mode in generated scanner\n" );
  951.     fprintf( stderr, "\t-f  generate fast, large scanner\n" );
  952.     fprintf( stderr, "\t-h  produce this help message\n" );
  953.     fprintf( stderr, "\t-i  generate case-insensitive scanner\n" );
  954.     fprintf( stderr, "\t-l  maximal compatibility with original lex\n" );
  955.     fprintf( stderr, "\t-n  do-nothing POSIX option\n" );
  956.     fprintf( stderr, "\t-p  generate performance report to stderr\n" );
  957.     fprintf( stderr,
  958.         "\t-s  suppress default rule to ECHO unmatched text\n" );
  959.     fprintf( stderr,
  960.     "\t-t  write generated scanner on stdout instead of lex.yy.c\n" );
  961.     fprintf( stderr,
  962.         "\t-v  write summary of scanner statistics to stderr\n" );
  963.     fprintf( stderr, "\t-w  do not generate warnings\n" );
  964.     fprintf( stderr, "\t-B  generate batch scanner (opposite of -I)\n" );
  965.     fprintf( stderr,
  966.         "\t-F  use alternative fast scanner representation\n" );
  967.     fprintf( stderr,
  968.         "\t-I  generate interactive scanner (opposite of -B)\n" );
  969.     fprintf( stderr, "\t-L  suppress #line directives in scanner\n" );
  970.     fprintf( stderr, "\t-T  %s should run in trace mode\n", program_name );
  971.     fprintf( stderr, "\t-V  report %s version\n", program_name );
  972.     fprintf( stderr, "\t-7  generate 7-bit scanner\n" );
  973.     fprintf( stderr, "\t-8  generate 8-bit scanner\n" );
  974.     fprintf( stderr, "\t-+  generate C++ scanner class\n" );
  975.     fprintf( stderr,
  976.     "\t-C  specify degree of table compression (default is -Cem):\n" );
  977.     fprintf( stderr,
  978.     "\t\t-Ca  trade off larger tables for better memory alignment\n" );
  979.     fprintf( stderr, "\t\t-Ce  construct equivalence classes\n" );
  980.     fprintf( stderr,
  981.     "\t\t-Cf  do not compress scanner tables; use -f representation\n" );
  982.     fprintf( stderr,
  983.     "\t\t-CF  do not compress scanner tables; use -F representation\n" );
  984.     fprintf( stderr, "\t\t-Cm  construct meta-equivalence classes\n" );
  985.     fprintf( stderr,
  986.         "\t\t-Cr  use read() instead of stdio for scanner input\n" );
  987.     fprintf( stderr, "\t-P  specify scanner prefix other than \"yy\"\n" );
  988.     fprintf( stderr, "\t-S  specify skeleton file\n" );
  989.     }
  990.